docs/examples/rates/LeR complete examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LeR complete examples\n",
    "\n",
    "* Please refer to the [documentation](https://ler.readthedocs.io/en/latest/) for more details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Short lensed/unlensed BBH example with three detectors\n",
    "\n",
    "* This part of the notebook is a short example to simulate lensed and unlensed binary black hole mergers and calculate their rates ($yr^{-1}$) and finally compare the results.\n",
    "* All the outputs are saved in the `ler_data` directory by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# call the LeR class\n",
    "from ler.rates import LeR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* class initialization\n",
    "* if you want the models and its parameters to print.\n",
    "\n",
    "    ```ler = LeR()```\n",
    "    \n",
    "* set 'npool' according to your machine's available CPU cores. Default is 4.\n",
    "* to check no. of cores, \n",
    "\n",
    "    ```import multiprocessing as mp```\n",
    "    \n",
    "    ```print(mp.cpu_count())```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z_to_luminosity_distance interpolator will be generated at ./interpolator_pickle/z_to_luminosity_distance/z_to_luminosity_distance_0.pickle\n",
      "differential_comoving_volume interpolator will be generated at ./interpolator_pickle/differential_comoving_volume/differential_comoving_volume_0.pickle\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "merger_rate_density_bbh_popI_II_oguri2018 interpolator will be generated at ./interpolator_pickle/merger_rate_density_bbh_popI_II_oguri2018/merger_rate_density_bbh_popI_II_oguri2018_0.pickle\n",
      "z_to_Dc interpolator will be generated at ./interpolator_pickle/z_to_Dc/z_to_Dc_0.pickle\n",
      "Dc_to_z interpolator will be generated at ./interpolator_pickle/Dc_to_z/Dc_to_z_0.pickle\n",
      "angular_diameter_distance interpolator will be generated at ./interpolator_pickle/angular_diameter_distance/angular_diameter_distance_0.pickle\n",
      "differential_comoving_volume interpolator will be generated at ./interpolator_pickle/differential_comoving_volume/differential_comoving_volume_1.pickle\n",
      "velocity_dispersion_ewoud interpolator will be generated at ./interpolator_pickle/velocity_dispersion_ewoud/velocity_dispersion_ewoud_0.pickle\n",
      "optical_depth_SIE_hemanta interpolator will be generated at ./interpolator_pickle/optical_depth_SIE_hemanta/optical_depth_SIE_hemanta_0.pickle\n",
      "Dl_to_z interpolator will be generated at ./interpolator_pickle/Dl_to_z/Dl_to_z_0.pickle\n",
      "psds not given. Choosing bilby's default psds\n",
      "npool:  4\n",
      "snr type:  interpolation\n",
      "waveform approximant:  IMRPhenomD\n",
      "sampling frequency:  2048.0\n",
      "minimum frequency (fmin):  20.0\n",
      "mtot=mass1+mass2\n",
      "min(mtot):  2.0\n",
      "max(mtot) (with the given fmin=20.0): 184.98599853446768\n",
      "detectors:  None\n",
      "min(ratio):  0.1\n",
      "max(ratio):  1.0\n",
      "mtot resolution:  500\n",
      "ratio resolution:  50\n",
      "interpolator directory:  ./interpolator_pickle\n",
      "Interpolator will be generated for L1 detector at ./interpolator_pickle/L1/partialSNR_dict_0.pickle\n",
      "Interpolator will be generated for H1 detector at ./interpolator_pickle/H1/partialSNR_dict_0.pickle\n",
      "Interpolator will be generated for V1 detector at ./interpolator_pickle/V1/partialSNR_dict_0.pickle\n",
      "Please be patient while the interpolator is generated\n",
      "Generating interpolator for ['L1', 'H1', 'V1'] detectors\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "interpolation for each mass_ratios: 100%|███████████████████████████| 50/50 [04:18<00:00,  5.17s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " LeR set up params:\n",
      "npool =  4\n",
      "z_min =  0.0\n",
      "z_max =  10.0\n",
      "event_type =  BBH\n",
      "size =  100000\n",
      "batch_size =  50000\n",
      "cosmology =  LambdaCDM(H0=70.0 km / (Mpc s), Om0=0.3, Ode0=0.7, Tcmb0=0.0 K, Neff=3.04, m_nu=None, Ob0=None)\n",
      "snr_finder =  <bound method GWSNR.snr of <gwsnr.gwsnr.GWSNR object at 0x105ef93c0>>\n",
      "json_file_names =  {'ler_params': 'ler_params.json', 'unlensed_param': 'unlensed_param.json', 'unlensed_param_detectable': 'unlensed_param_detectable.json', 'lensed_param': 'lensed_param.json', 'lensed_param_detectable': 'lensed_param_detectable.json'}\n",
      "interpolator_directory =  ./interpolator_pickle\n",
      "ler_directory =  ./ler_data\n",
      "\n",
      " LeR also takes CBCSourceParameterDistribution params as kwargs, as follows:\n",
      "source_priors= {'merger_rate_density': 'merger_rate_density_bbh_popI_II_oguri2018', 'source_frame_masses': 'binary_masses_BBH_popI_II_powerlaw_gaussian', 'zs': 'sample_source_redshift', 'geocent_time': 'sampler_uniform', 'ra': 'sampler_uniform', 'dec': 'sampler_cosine', 'phase': 'sampler_uniform', 'psi': 'sampler_uniform', 'theta_jn': 'sampler_sine'}\n",
      "source_priors_params= {'merger_rate_density': {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}, 'source_frame_masses': {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}, 'zs': None, 'geocent_time': {'min_': 1238166018, 'max_': 1269702018}, 'ra': {'min_': 0.0, 'max_': 6.283185307179586}, 'dec': None, 'phase': {'min_': 0.0, 'max_': 6.283185307179586}, 'psi': {'min_': 0.0, 'max_': 3.141592653589793}, 'theta_jn': None}\n",
      "spin_zero= True\n",
      "spin_precession= False\n",
      "create_new_interpolator= False\n",
      "\n",
      " LeR also takes LensGalaxyParameterDistribution params as kwargs, as follows:\n",
      "lens_type =  epl_galaxy\n",
      "lens_functions =  {'strong_lensing_condition': 'rjs_with_cross_section_SIE', 'optical_depth': 'optical_depth_SIE_hemanta', 'param_sampler_type': 'sample_all_routine'}\n",
      "lens_priors =  {'source_redshift_sl': 'strongly_lensed_source_redshifts', 'lens_redshift': 'lens_redshift_SDSS_catalogue', 'velocity_dispersion': 'velocity_dispersion_ewoud', 'axis_ratio': 'axis_ratio_rayleigh', 'axis_rotation_angle': 'axis_rotation_angle_uniform', 'shear': 'shear_norm', 'mass_density_spectral_index': 'mass_density_spectral_index_normal', 'source_parameters': 'sample_gw_parameters'}\n",
      "lens_priors_params =  {'source_redshift_sl': None, 'lens_redshift': None, 'velocity_dispersion': None, 'axis_ratio': {'q_min': 0.2, 'q_max': 1.0}, 'axis_rotation_angle': {'phi_min': 0.0, 'phi_max': 6.283185307179586}, 'shear': {'scale': 0.05}, 'mass_density_spectral_index': {'mean': 2.0, 'std': 0.2}, 'source_parameters': None}\n",
      "\n",
      " Image properties:\n",
      "n_min_images =  2\n",
      "n_max_images =  4\n",
      "geocent_time_min =  1126259462.4\n",
      "geocent_time_max =  1756979462.4\n",
      "lens_model_list =  ['EPL_NUMBA', 'SHEAR']\n",
      "\n",
      " LeR also takes gwsnr.GWSNR params as kwargs, as follows:\n",
      "mtot_min =  2.0\n",
      "mtot_max =  184.98599853446768\n",
      "ratio_min =  0.1\n",
      "ratio_max =  1.0\n",
      "mtot_resolution =  500\n",
      "ratio_resolution =  50\n",
      "sampling_frequency =  2048.0\n",
      "waveform_approximant =  IMRPhenomD\n",
      "minimum_frequency =  20.0\n",
      "snr_type =  interpolation\n",
      "psds =  [PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/AdV_asd.txt')]\n",
      "ifos =  None\n",
      "interpolator_dir =  ./interpolator_pickle\n",
      "create_new_interpolator =  False\n",
      "gwsnr_verbose =  True\n",
      "multiprocessing_verbose =  True\n",
      "mtot_cut =  True\n",
      "\n",
      " For reference, the chosen source parameters are listed below:\n",
      "merger_rate_density =  merger_rate_density_bbh_popI_II_oguri2018\n",
      "merger_rate_density_params =  {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}\n",
      "source_frame_masses =  binary_masses_BBH_popI_II_powerlaw_gaussian\n",
      "source_frame_masses_params =  {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}\n",
      "geocent_time =  sampler_uniform\n",
      "geocent_time_params =  {'min_': 1238166018, 'max_': 1269702018}\n",
      "ra =  sampler_uniform\n",
      "ra_params =  {'min_': 0.0, 'max_': 6.283185307179586}\n",
      "dec =  sampler_cosine\n",
      "dec_params =  None\n",
      "phase =  sampler_uniform\n",
      "phase_params =  {'min_': 0.0, 'max_': 6.283185307179586}\n",
      "psi =  sampler_uniform\n",
      "psi_params =  {'min_': 0.0, 'max_': 3.141592653589793}\n",
      "theta_jn =  sampler_sine\n",
      "theta_jn_params =  None\n",
      "\n",
      " For reference, the chosen lens related parameters and functions are listed below:\n",
      "lens_redshift =  lens_redshift_SDSS_catalogue\n",
      "lens_redshift_params =  None\n",
      "velocity_dispersion =  velocity_dispersion_ewoud\n",
      "velocity_dispersion_params =  None\n",
      "axis_ratio =  axis_ratio_rayleigh\n",
      "axis_ratio_params =  {'q_min': 0.2, 'q_max': 1.0}\n",
      "axis_rotation_angle =  axis_rotation_angle_uniform\n",
      "axis_rotation_angle_params =  {'phi_min': 0.0, 'phi_max': 6.283185307179586}\n",
      "shear =  shear_norm\n",
      "shear_params =  {'scale': 0.05}\n",
      "mass_density_spectral_index =  mass_density_spectral_index_normal\n",
      "mass_density_spectral_index_params =  {'mean': 2.0, 'std': 0.2}\n",
      "Lens functions:\n",
      "strong_lensing_condition =  rjs_with_cross_section_SIE\n",
      "optical_depth =  optical_depth_SIE_hemanta\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "ler = LeR(verbose=True, create_new_interpolator=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation of the GW CBC population (unlensed).\n",
    "\n",
    "* this will generate a json file with the simulated population parameters\n",
    "* by default 100,000 events will be sampled with batches of 50,000. For more realistic results, keep batch_size=50000 and size>=1000000.\n",
    "* results will be saved in the same directory as json file.\n",
    "* resume=True will resume the simulation from the last saved batch.\n",
    "* if you dont't need to save the file at the end of each batch sampling, set save_batch=False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed params will be store in ./ler_data/unlensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "Batch no. 2\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "saving all unlensed_params in ./ler_data/unlensed_param.json...\n"
     ]
    }
   ],
   "source": [
    "# ler.batch_size = 100000 # for faster computation\n",
    "unlensed_param = ler.unlensed_cbc_statistics(size=100000, resume=False, save_batch=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculation of unlensed rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting unlensed_params from json file ./ler_data/unlensed_param.json...\n",
      "given detectability_condition == 'step_function'\n",
      "total unlensed rate (yr^-1) (with step function): 405.8097545623249\n",
      "number of simulated unlensed detectable events: 392\n",
      "number of all simulated unlensed events: 100000\n",
      "storing detectable unlensed params in ./ler_data/unlensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "_, data = ler.unlensed_rate();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'optimal_snr_net'])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulation of the GW CBC population (lensed).\n",
    "\n",
    "* this will generate a json file with the simulated source parameters, lensed parameters and image parameters.\n",
    "* if the program hangs dues to memory issues,\n",
    "  * try reducing the batch size.\n",
    "  * and you can resume from the last saved batch. But you need to set save_batch=True.\n",
    "  * save_batch=False will make the code run faster but you will not have the results saved in the end of each batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lensed params will be store in ./ler_data/lensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3453.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "Batch no. 2\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:13<00:00, 3597.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 4 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 4/4 [00:02<00:00,  1.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "saving all lensed_params in ./ler_data/lensed_param.json...\n"
     ]
    }
   ],
   "source": [
    "# ler.batch_size = 50000\n",
    "lensed_param = ler.lensed_cbc_statistics(size=100000, resume=False, save_batch=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* what are the saved files?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ler_params': 'ler_params.json',\n",
       " 'unlensed_param': 'unlensed_param.json',\n",
       " 'unlensed_param_detectable': 'unlensed_param_detectable.json',\n",
       " 'lensed_param': 'lensed_param.json',\n",
       " 'lensed_param_detectable': 'lensed_param_detectable.json'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ler.json_file_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculation of lensed rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting lensed_params from json file ./ler_data/lensed_param.json...\n",
      "given detectability_condition == 'step_function'\n",
      "total lensed rate (yr^-1) (with step function): 1.0330580915256682\n",
      "number of simulated lensed detectable events: 416\n",
      "number of simulated all lensed events: 100000\n",
      "storing detectable lensed params in ./ler_data/lensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "ler.lensed_rate();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison of the rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed_rate: 405.8097545623249\n",
      "lensed_rate: 1.0330580915256682\n",
      "ratio: 392.82375104676464\n"
     ]
    }
   ],
   "source": [
    "ler.rate_ratio();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* if you want to calculate the rates, and compare it at the same time, run the following command.\n",
    "\n",
    "    ```rate_ratio, unlensed_param_detectable, lensed_param_detectable =ler.rate_comparision_with_rate_calculation()```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* looking at the available parameters\n",
    "* Note: This is for spin-less systems. IMRPhenomD (spin-less) is the default waveform approximant. To see LeR configuration, run\n",
    "\n",
    "    ```ler.print_all_params()```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### getting generated parameters\n",
    "\n",
    "* you can use ler attributes or call the relevant json file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'optimal_snr_net'])\n",
      "dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'optimal_snr_net', 'L1', 'H1', 'V1'])\n"
     ]
    }
   ],
   "source": [
    "unlensed_param_detectable = ler.unlensed_param_detectable\n",
    "lensed_param_detectable = ler.lensed_param_detectable\n",
    "print(unlensed_param_detectable.keys())\n",
    "print(lensed_param_detectable.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Note: all ler initialization parameters and results are saved in a json file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['npool', 'z_min', 'z_max', 'size', 'batch_size', 'cosmology', 'snr_finder', 'json_file_names', 'interpolator_directory', 'gw_param_sampler_dict', 'snr_calculator_dict', 'detectable_unlensed_rate_per_year', 'detectability_condition', 'detectable_lensed_rate_per_year', 'rate_ratio'])\n",
      "detectable_unlensed_rate_per_year:  405.8097545623249\n",
      "detectable_lensed_rate_per_year;  1.0330580915256682\n",
      "rate_ratio:  392.82375104676464\n"
     ]
    }
   ],
   "source": [
    "from ler.utils import load_json\n",
    "# ler_params = load_json(ler.ler_directory+\"/\"+ler.json_file_names[\"lensed_params\"])\n",
    "ler_params = load_json('ler_data/ler_params.json')\n",
    "print(ler_params.keys())\n",
    "print(\"detectable_unlensed_rate_per_year: \", ler_params['detectable_unlensed_rate_per_year'])\n",
    "print(\"detectable_lensed_rate_per_year; \",ler_params['detectable_lensed_rate_per_year'])\n",
    "print(\"rate_ratio: \",ler_params['rate_ratio'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting gw_params from json file ler_data/unlensed_param_detectable.json...\n",
      "getting gw_params from json file ler_data/unlensed_param.json...\n",
      "getting gw_params from json file ler_data/lensed_param_detectable.json...\n",
      "getting gw_params from json file ler_data/lensed_param.json...\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# quick plot\n",
    "import matplotlib.pyplot as plt\n",
    "from ler.utils import plots as lerplt\n",
    "\n",
    "# plotting the distribution of event parameters\n",
    "# comparision of redshift distribution for lensed and unlensed events\n",
    "# param_dict can be either a dictionary or a json file name that contains the parameters\n",
    "plt.figure(figsize=(6, 4))\n",
    "# for unlensed case\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/unlensed_param_detectable.json',\n",
    "    plot_label='zs (bbh-detectable)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    "    kde_bandwidth=0.5,\n",
    ")\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/unlensed_param.json',\n",
    "    plot_label='zs (bbh-all)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    ")\n",
    "# for lensed case\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/lensed_param_detectable.json',\n",
    "    plot_label='zs (bbh-lensed-detectable)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    "    kde_bandwidth=0.5,\n",
    ")\n",
    "lerplt.param_plot(\n",
    "    param_name='zs',\n",
    "    param_dict='ler_data/lensed_param.json',\n",
    "    plot_label='zs (bbh-lensed-all)',\n",
    "    histogram=False,\n",
    "    kde=True,\n",
    ")\n",
    "plt.xlim(0.001,8)\n",
    "plt.grid(alpha=0.4)\n",
    "plt.xlabel('Source redshift (zs)')\n",
    "plt.ylabel('Probability Density')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom functions\n",
    "\n",
    "* `ler` allows internal model functions to be change with custom functions.\n",
    "\n",
    "* It also allows to change the default parameters of the existing model functions.\n",
    "\n",
    "First let's look at what are the input parameters available for ler.LeR. The input paramters can divided into five categories\n",
    "\n",
    "1. ler.LeR set up params\n",
    "\n",
    "2. ler.CBCSourceParameterDistribution set up params (as kwargs)\n",
    "\n",
    "3. ler.LensGalaxyParameterDistribution set up params (as kwargs)\n",
    "\n",
    "4. ler.ImageProperties set up params (as kwargs)\n",
    "\n",
    "5. gwsnr.GWSNR set up params (as kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z_to_luminosity_distance interpolator will be loaded from ./interpolator_pickle/z_to_luminosity_distance/z_to_luminosity_distance_0.pickle\n",
      "differential_comoving_volume interpolator will be loaded from ./interpolator_pickle/differential_comoving_volume/differential_comoving_volume_0.pickle\n",
      "merger_rate_density_bbh_popI_II_oguri2018 interpolator will be loaded from ./interpolator_pickle/merger_rate_density_bbh_popI_II_oguri2018/merger_rate_density_bbh_popI_II_oguri2018_0.pickle\n",
      "z_to_Dc interpolator will be loaded from ./interpolator_pickle/z_to_Dc/z_to_Dc_0.pickle\n",
      "Dc_to_z interpolator will be loaded from ./interpolator_pickle/Dc_to_z/Dc_to_z_0.pickle\n",
      "angular_diameter_distance interpolator will be loaded from ./interpolator_pickle/angular_diameter_distance/angular_diameter_distance_0.pickle\n",
      "differential_comoving_volume interpolator will be loaded from ./interpolator_pickle/differential_comoving_volume/differential_comoving_volume_1.pickle\n",
      "velocity_dispersion_ewoud interpolator will be loaded from ./interpolator_pickle/velocity_dispersion_ewoud/velocity_dispersion_ewoud_0.pickle\n",
      "optical_depth_SIE_hemanta interpolator will be loaded from ./interpolator_pickle/optical_depth_SIE_hemanta/optical_depth_SIE_hemanta_0.pickle\n",
      "Dl_to_z interpolator will be loaded from ./interpolator_pickle/Dl_to_z/Dl_to_z_0.pickle\n",
      "psds not given. Choosing bilby's default psds\n",
      "npool:  4\n",
      "snr type:  interpolation\n",
      "waveform approximant:  IMRPhenomD\n",
      "sampling frequency:  2048.0\n",
      "minimum frequency (fmin):  20.0\n",
      "mtot=mass1+mass2\n",
      "min(mtot):  2.0\n",
      "max(mtot) (with the given fmin=20.0): 184.98599853446768\n",
      "detectors:  None\n",
      "min(ratio):  0.1\n",
      "max(ratio):  1.0\n",
      "mtot resolution:  500\n",
      "ratio resolution:  50\n",
      "interpolator directory:  ./interpolator_pickle\n",
      "Interpolator will be loaded for L1 detector from ./interpolator_pickle/L1/partialSNR_dict_0.pickle\n",
      "Interpolator will be loaded for H1 detector from ./interpolator_pickle/H1/partialSNR_dict_0.pickle\n",
      "Interpolator will be loaded for V1 detector from ./interpolator_pickle/V1/partialSNR_dict_0.pickle\n",
      "\n",
      " LeR set up params:\n",
      "npool =  4\n",
      "z_min =  0.0\n",
      "z_max =  10.0\n",
      "event_type =  BBH\n",
      "size =  100000\n",
      "batch_size =  50000\n",
      "cosmology =  LambdaCDM(H0=70.0 km / (Mpc s), Om0=0.3, Ode0=0.7, Tcmb0=0.0 K, Neff=3.04, m_nu=None, Ob0=None)\n",
      "snr_finder =  <bound method GWSNR.snr of <gwsnr.gwsnr.GWSNR object at 0x1621e77f0>>\n",
      "json_file_names =  {'ler_params': 'ler_params.json', 'unlensed_param': 'unlensed_param.json', 'unlensed_param_detectable': 'unlensed_param_detectable.json', 'lensed_param': 'lensed_param.json', 'lensed_param_detectable': 'lensed_param_detectable.json'}\n",
      "interpolator_directory =  ./interpolator_pickle\n",
      "ler_directory =  ./ler_data\n",
      "\n",
      " LeR also takes CBCSourceParameterDistribution params as kwargs, as follows:\n",
      "source_priors= {'merger_rate_density': 'merger_rate_density_bbh_popI_II_oguri2018', 'source_frame_masses': 'binary_masses_BBH_popI_II_powerlaw_gaussian', 'zs': 'sample_source_redshift', 'geocent_time': 'sampler_uniform', 'ra': 'sampler_uniform', 'dec': 'sampler_cosine', 'phase': 'sampler_uniform', 'psi': 'sampler_uniform', 'theta_jn': 'sampler_sine'}\n",
      "source_priors_params= {'merger_rate_density': {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}, 'source_frame_masses': {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}, 'zs': None, 'geocent_time': {'min_': 1238166018, 'max_': 1269702018}, 'ra': {'min_': 0.0, 'max_': 6.283185307179586}, 'dec': None, 'phase': {'min_': 0.0, 'max_': 6.283185307179586}, 'psi': {'min_': 0.0, 'max_': 3.141592653589793}, 'theta_jn': None}\n",
      "spin_zero= True\n",
      "spin_precession= False\n",
      "create_new_interpolator= False\n",
      "\n",
      " LeR also takes LensGalaxyParameterDistribution params as kwargs, as follows:\n",
      "lens_type =  epl_galaxy\n",
      "lens_functions =  {'strong_lensing_condition': 'rjs_with_cross_section_SIE', 'optical_depth': 'optical_depth_SIE_hemanta', 'param_sampler_type': 'sample_all_routine'}\n",
      "lens_priors =  {'source_redshift_sl': 'strongly_lensed_source_redshifts', 'lens_redshift': 'lens_redshift_SDSS_catalogue', 'velocity_dispersion': 'velocity_dispersion_ewoud', 'axis_ratio': 'axis_ratio_rayleigh', 'axis_rotation_angle': 'axis_rotation_angle_uniform', 'shear': 'shear_norm', 'mass_density_spectral_index': 'mass_density_spectral_index_normal', 'source_parameters': 'sample_gw_parameters'}\n",
      "lens_priors_params =  {'source_redshift_sl': None, 'lens_redshift': None, 'velocity_dispersion': None, 'axis_ratio': {'q_min': 0.2, 'q_max': 1.0}, 'axis_rotation_angle': {'phi_min': 0.0, 'phi_max': 6.283185307179586}, 'shear': {'scale': 0.05}, 'mass_density_spectral_index': {'mean': 2.0, 'std': 0.2}, 'source_parameters': None}\n",
      "\n",
      " Image properties:\n",
      "n_min_images =  2\n",
      "n_max_images =  4\n",
      "geocent_time_min =  1126259462.4\n",
      "geocent_time_max =  1756979462.4\n",
      "lens_model_list =  ['EPL_NUMBA', 'SHEAR']\n",
      "\n",
      " LeR also takes gwsnr.GWSNR params as kwargs, as follows:\n",
      "mtot_min =  2.0\n",
      "mtot_max =  184.98599853446768\n",
      "ratio_min =  0.1\n",
      "ratio_max =  1.0\n",
      "mtot_resolution =  500\n",
      "ratio_resolution =  50\n",
      "sampling_frequency =  2048.0\n",
      "waveform_approximant =  IMRPhenomD\n",
      "minimum_frequency =  20.0\n",
      "snr_type =  interpolation\n",
      "psds =  [PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/aLIGO_O4_high_asd.txt'), PowerSpectralDensity(psd_file='None', asd_file='/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/bilby/gw/detector/noise_curves/AdV_asd.txt')]\n",
      "ifos =  None\n",
      "interpolator_dir =  ./interpolator_pickle\n",
      "create_new_interpolator =  False\n",
      "gwsnr_verbose =  True\n",
      "multiprocessing_verbose =  True\n",
      "mtot_cut =  True\n",
      "\n",
      " For reference, the chosen source parameters are listed below:\n",
      "merger_rate_density =  merger_rate_density_bbh_popI_II_oguri2018\n",
      "merger_rate_density_params =  {'R0': 2.39e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}\n",
      "source_frame_masses =  binary_masses_BBH_popI_II_powerlaw_gaussian\n",
      "source_frame_masses_params =  {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}\n",
      "geocent_time =  sampler_uniform\n",
      "geocent_time_params =  {'min_': 1238166018, 'max_': 1269702018}\n",
      "ra =  sampler_uniform\n",
      "ra_params =  {'min_': 0.0, 'max_': 6.283185307179586}\n",
      "dec =  sampler_cosine\n",
      "dec_params =  None\n",
      "phase =  sampler_uniform\n",
      "phase_params =  {'min_': 0.0, 'max_': 6.283185307179586}\n",
      "psi =  sampler_uniform\n",
      "psi_params =  {'min_': 0.0, 'max_': 3.141592653589793}\n",
      "theta_jn =  sampler_sine\n",
      "theta_jn_params =  None\n",
      "\n",
      " For reference, the chosen lens related parameters and functions are listed below:\n",
      "lens_redshift =  lens_redshift_SDSS_catalogue\n",
      "lens_redshift_params =  None\n",
      "velocity_dispersion =  velocity_dispersion_ewoud\n",
      "velocity_dispersion_params =  None\n",
      "axis_ratio =  axis_ratio_rayleigh\n",
      "axis_ratio_params =  {'q_min': 0.2, 'q_max': 1.0}\n",
      "axis_rotation_angle =  axis_rotation_angle_uniform\n",
      "axis_rotation_angle_params =  {'phi_min': 0.0, 'phi_max': 6.283185307179586}\n",
      "shear =  shear_norm\n",
      "shear_params =  {'scale': 0.05}\n",
      "mass_density_spectral_index =  mass_density_spectral_index_normal\n",
      "mass_density_spectral_index_params =  {'mean': 2.0, 'std': 0.2}\n",
      "Lens functions:\n",
      "strong_lensing_condition =  rjs_with_cross_section_SIE\n",
      "optical_depth =  optical_depth_SIE_hemanta\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from ler.rates import LeR\n",
    "ler = LeR(npool=4)  # verbose=True "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, I will change,\n",
    "\n",
    "  * merger_rate_density_params's default value of **local merger rate density** ($R_0$) to 2.3e-9 $Mpc^{-3} yr^{-1}$. But, I am still using the default merger_rate_density function, which is 'merger_rate_density_bbh_popI_II_oguri2018'.\n",
    "\n",
    "  * **source_frame_masses** to a custom function. This is similar to the internal default function, i.e. PowerLaw+Peak model. I am using `gwcosmo`'s powerlaw_gaussian prior for this example.\n",
    "\n",
    "  * **optical depth** for strong lensing condition and **velocity dispersion** of the lensing galaxy to SIS model and gamma function respectively. The default optical depth is for the SIE model and default velocity dispersion has additional redshift dependence.\n",
    "  \n",
    "  * `gwsnr` parameters: By default, it uses 'IMRPhenomD' **waveform model** with no spin. It uses interpolation method to find the 'snr' and it is super fast. But for the example below, I am using 'IMRPhenomXPHM` with precessing spins. This is without interpolation but through inner product method. It will be slower."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gwcosmo import priors as p\n",
    "\n",
    "# define your custom function of mass_1_source and mass_2_source calculation\n",
    "# it should have 'size' as the only argument\n",
    "def powerlaw_peak(size):\n",
    "    \"\"\"\n",
    "    Function to sample mass1 and mass2 from a powerlaw with a gaussian peak\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    size : `int`\n",
    "        Number of samples to draw\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    mass_1_source : `numpy.ndarray`\n",
    "        Array of mass1 samples\n",
    "    mass_2_source : `numpy.ndarray`\n",
    "        Array of mass2 samples\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "    # below is the gwcosmo default values\n",
    "    mminbh=4.98  # Minimum mass of the black hole (Msun)\n",
    "    mmaxbh=86.22  # Maximum mass of the black hole (Msun) \n",
    "    alpha=2.63  # Spectral index for the powerlaw of the primary mass distribution\n",
    "    mu_g=33.07  # Mean of the Gaussian component in the primary mass distribution\n",
    "    sigma_g=5.69  # Width of the Gaussian component in the primary mass distribution\n",
    "    lambda_peak=0.10  # Fraction of the model in the Gaussian component\n",
    "    delta_m=4.82  # Range of mass tapering on the lower end of the mass distribution\n",
    "    beta=1.26  # Spectral index for the powerlaw of the mass ratio distribution\n",
    "\n",
    "    model = p.BBH_powerlaw_gaussian(\n",
    "        mminbh=mminbh,\n",
    "        mmaxbh=mmaxbh,\n",
    "        alpha=alpha,\n",
    "        mu_g=mu_g,\n",
    "        sigma_g=sigma_g,\n",
    "        lambda_peak=lambda_peak,\n",
    "        delta_m=delta_m,\n",
    "        beta=beta,\n",
    "    )\n",
    "    # sample mass1 and mass2\n",
    "    mass_1_source, mass_2_source = model.sample(Nsample=size)\n",
    "\n",
    "    return (mass_1_source, mass_2_source)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Initialize the class with the custom function\n",
    "\n",
    "* changing ler input params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "\n",
    "ler = LeR(npool=4, verbose=False,\n",
    "    # for source parameters  \n",
    "    source_priors=dict(\n",
    "        merger_rate_density='merger_rate_density_bbh_popI_II_oguri2018',\n",
    "        source_frame_masses=powerlaw_peak,\n",
    "    ),\n",
    "    source_priors_params=dict(\n",
    "        merger_rate_density=dict(\n",
    "            R0=2.9e-08,\n",
    "            b2=1.6,\n",
    "            b3=2.0,\n",
    "            b4=30\n",
    "        ),\n",
    "        source_frame_masses=None,\n",
    "    ),\n",
    "    # for lens parameters\n",
    "    lens_functions=dict(\n",
    "        strong_lensing_condition=\"rjs_with_cross_section_SIS\",\n",
    "        optical_depth=\"optical_depth_SIS_haris\",\n",
    "    ),\n",
    "    lens_priors=dict(\n",
    "        velocity_dispersion=\"velocity_dispersion_gengamma\",\n",
    "    ),\n",
    "    lens_priors_params=dict(\n",
    "        velocity_dispersion=dict(a=2.32 / 2.67, c=2.67)\n",
    "    ),\n",
    "    # for snr generation\n",
    "    waveform_approximant = 'IMRPhenomXPHM',\n",
    "    snr_type='inner_product',\n",
    "    spin_zero=False,\n",
    "    spin_precession=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed params will be store in ./ler_data/new_unlensed_params.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 40572/40572 [02:10<00:00, 310.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch no. 2\n",
      "sampling gw source params...\n",
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 40780/40780 [00:56<00:00, 719.38it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saving all unlensed_params in ./ler_data/new_unlensed_params.json...\n"
     ]
    }
   ],
   "source": [
    "ler.batch_size = 50000\n",
    "ler.unlensed_cbc_statistics(size=100000, resume=False, output_jsonfile = 'new_unlensed_params.json');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lensed params will be store in ./ler_data/new_lensed_params.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/gwcosmo/prior/custom_math_priors.py:48: RuntimeWarning: overflow encountered in exp\n",
      "  effe_prime[select_window] = _np.exp(_np.nan_to_num((delta_m/mprime[select_window])+(delta_m/(mprime[select_window]-delta_m))))\n",
      "/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/gwcosmo/prior/custom_math_priors.py:162: RuntimeWarning: divide by zero encountered in log\n",
      "  prob_ret =self.origin_prob.log_prob(x)+_np.log(window)\n",
      "/Users/phurailatpamhemantakumar/anaconda3/envs/ler/lib/python3.10/site-packages/gwcosmo/prior/custom_math_priors.py:160: RuntimeWarning: divide by zero encountered in log\n",
      "  prob_ret =self.origin_prob.log_prob(x)+_np.log(window)-_np.log(self.norm)\n",
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3402.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 1 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|████████████████████████████████████████████████████████| 36386/36386 [00:42<00:00, 864.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 36303/36303 [00:42<00:00, 859.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 5296/5296 [00:09<00:00, 576.36it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 4523/4523 [00:07<00:00, 592.17it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch no. 2\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3359.80it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 1 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.99s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating snrs...\n",
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|████████████████████████████████████████████████████████| 36156/36156 [00:42<00:00, 857.64it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████| 36096/36096 [00:42<00:00, 853.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 5232/5232 [00:09<00:00, 574.98it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solving SNR with inner product\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████| 4402/4402 [00:07<00:00, 586.65it/s]\n"
     ]
    }
   ],
   "source": [
    "ler.lensed_cbc_statistics(size=100000, resume=False, output_jsonfile = 'new_lensed_params.json');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* generate detectable events and compute the rate ratio\n",
    "\n",
    "* note: here no input params are provided, so it will track the json files generated above\n",
    "\n",
    "* For individual rate computation, use\n",
    "    ```ler.unlensed_rate();```\n",
    "    ```ler.lensed_rate();```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting unlensed_params from json file ./ler_data/new_unlensed_params.json...\n",
      "given detectability_condition == 'step_function'\n",
      "total unlensed rate (yr^-1) (with step function): 896.5082843137075\n",
      "number of simulated unlensed detectable events: 866\n",
      "number of all simulated unlensed events: 100000\n",
      "storing detectable unlensed params in ./ler_data/new_unlensed_params_detectable.json\n",
      "getting lensed_params from json file ./ler_data/new_lensed_params.json...\n",
      "given detectability_condition == 'step_function'\n",
      "total lensed rate (yr^-1) (with step function): 0.6570084100456169\n",
      "number of simulated lensed detectable events: 650\n",
      "number of simulated all lensed events: 100000\n",
      "storing detectable lensed params in ./ler_data/new_lensed_params_detectable.json\n",
      "unlensed_rate (per year): 896.5082843137075\n",
      "lensed_rate (per year): 0.6570084100456169\n",
      "ratio: 1364.5309110296803\n"
     ]
    }
   ],
   "source": [
    "rate_ratio, unlensed_param_detectable, lensed_param_detectable =ler.rate_comparision_with_rate_calculation(\n",
    "    unlensed_param='new_unlensed_params.json',\n",
    "    snr_threshold_unlensed=8.0,\n",
    "    lensed_param='new_lensed_params.json',\n",
    "    output_jsonfile_unlensed='new_unlensed_params_detectable.json',\n",
    "    output_jsonfile_lensed='new_lensed_params_detectable.json',\n",
    "    snr_threshold_lensed=[8.0,8.0],\n",
    "    num_img=[1,1],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important Note:**\n",
    "* input parameters, snr_threshold_lensed=[8.0,8.0], num_img=[1,1], means that two of the images should have snr>8.0. You can also set: snr_threshold_lensed=8, num_img=2\n",
    "\n",
    "* Similarly, if snr_threshold_lensed=[8.0,6.0], num_img=[2,2], it means that two of the images should have snr>8.0 and other two images should have snr>6.0. But in this case, even though the simulated lensed (detectable) events are correct, the rate calculation will not be right as the strong lensing condition was set for 2 image case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'ler_params': 'ler_params.json',\n",
       " 'unlensed_param': 'new_unlensed_params.json',\n",
       " 'unlensed_param_detectable': 'new_unlensed_params_detectable.json',\n",
       " 'lensed_param': 'new_lensed_params.json',\n",
       " 'lensed_param_detectable': 'new_lensed_params_detectable.json'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to check all the stored json file names\n",
    "# all this files are stored in the ler.ler_directory\n",
    "ler.json_file_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* again you can call the generated detectable events' parameters using an instance attribute\n",
    "\n",
    "* Note: The data is not stored in this instance attribute, it is stored in the json file. This scheme is used to save RAM memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'a_1', 'a_2', 'tilt_1', 'tilt_2', 'phi_12', 'phi_jl', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'optimal_snr_net'])\n",
      "dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'a_1', 'a_2', 'tilt_1', 'tilt_2', 'phi_12', 'phi_jl', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'optimal_snr_net', 'L1', 'H1', 'V1'])\n"
     ]
    }
   ],
   "source": [
    "unlensed_param_detectable = ler.unlensed_param_detectable\n",
    "print(unlensed_param_detectable.keys())\n",
    "lensed_param_detectable = ler.lensed_param_detectable\n",
    "print(lensed_param_detectable.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to look for available model functions?\n",
    "\n",
    "* All available names are stored as a dict in `ler` instance\n",
    "\n",
    "* the keys of this dict shows the parameter type\n",
    "\n",
    "* the values are also dict, where the keys are the model function names and the values are their input parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'binary_masses_BBH_popI_II_powerlaw_gaussian': {'mminbh': 4.98, 'mmaxbh': 112.5, 'alpha': 3.78, 'mu_g': 32.27, 'sigma_g': 3.88, 'lambda_peak': 0.03, 'delta_m': 4.8, 'beta': 0.81}, 'binary_masses_BBH_popIII_lognormal': {'Mc': 30.0, 'sigma': 0.3, 'beta': 1.1}, 'binary_masses_BBH_primordial_lognormal': {'Mc': 30.0, 'sigma': 0.3, 'beta': 1.1}, 'binary_masses_BNS_gwcosmo': {'mminns': 1.0, 'mmaxns': 3.0, 'alphans': 0.0}, 'binary_masses_BNS_bimodal': {'w': 0.643, 'muL': 1.352, 'sigmaL': 0.08, 'muR': 1.88, 'sigmaR': 0.3, 'mmin': 1.0, 'mmax': 2.3}}\n",
      "{'velocity_dispersion_haris': {'a': 0.8689138576779026, 'c': 2.67}, 'velocity_dispersion_gengamma': {'a': 0.8689138576779026, 'c': 2.67}, 'velocity_dispersion_bernardi': None, 'velocity_dispersion_ewoud': None}\n"
     ]
    }
   ],
   "source": [
    "# for unlensed case\n",
    "print(ler.available_gw_prior_list_and_its_params['source_frame_masses'])\n",
    "# for lensed case\n",
    "print(ler.available_lens_prior_list_and_its_params['velocity_dispersion'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* for looking at the choosen models and its input parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'merger_rate_density': 'merger_rate_density_bbh_popI_II_oguri2018', 'source_frame_masses': <function powerlaw_peak at 0x29b625e10>, 'zs': 'sample_source_redshift', 'geocent_time': 'sampler_uniform', 'ra': 'sampler_uniform', 'dec': 'sampler_cosine', 'phase': 'sampler_uniform', 'psi': 'sampler_uniform', 'theta_jn': 'sampler_sine', 'a_1': 'sampler_uniform', 'a_2': 'sampler_uniform', 'tilt_1': 'sampler_sine', 'tilt_2': 'sampler_sine', 'phi_12': 'sampler_uniform', 'phi_jl': 'sampler_uniform'}\n",
      "{'merger_rate_density': {'R0': 2.9e-08, 'b2': 1.6, 'b3': 2.0, 'b4': 30}, 'source_frame_masses': None, 'zs': None, 'geocent_time': {'min_': 1238166018, 'max_': 1269702018}, 'ra': {'min_': 0.0, 'max_': 6.283185307179586}, 'dec': None, 'phase': {'min_': 0.0, 'max_': 6.283185307179586}, 'psi': {'min_': 0.0, 'max_': 3.141592653589793}, 'theta_jn': None, 'a_1': {'min_': 0.0, 'max_': 0.8}, 'a_2': {'min_': 0.0, 'max_': 0.8}, 'tilt_1': None, 'tilt_2': None, 'phi_12': {'min_': 0, 'max_': 6.283185307179586}, 'phi_jl': {'min_': 0, 'max_': 6.283185307179586}}\n",
      "{'source_redshift_sl': 'strongly_lensed_source_redshifts', 'lens_redshift': 'lens_redshift_SDSS_catalogue', 'velocity_dispersion': 'velocity_dispersion_gengamma', 'axis_ratio': 'axis_ratio_rayleigh', 'axis_rotation_angle': 'axis_rotation_angle_uniform', 'shear': 'shear_norm', 'mass_density_spectral_index': 'mass_density_spectral_index_normal', 'source_parameters': 'sample_gw_parameters'}\n",
      "{'source_redshift_sl': None, 'lens_redshift': None, 'velocity_dispersion': {'a': 0.8689138576779026, 'c': 2.67}, 'axis_ratio': {'q_min': 0.2, 'q_max': 1.0}, 'axis_rotation_angle': {'phi_min': 0.0, 'phi_max': 6.283185307179586}, 'shear': {'scale': 0.05}, 'mass_density_spectral_index': {'mean': 2.0, 'std': 0.2}, 'source_parameters': None}\n"
     ]
    }
   ],
   "source": [
    "# for unlensed case\n",
    "print(ler.gw_param_samplers)\n",
    "print(ler.gw_param_samplers_params)\n",
    "# for lensed case\n",
    "print(ler.lens_param_samplers)\n",
    "print(ler.lens_param_samplers_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using internal model functions\n",
    "\n",
    "### Mass distribution of BBH (mass-1, larger mass only)\n",
    "\n",
    "* compare the default mass distribution with the custom mass distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calling the default mass distribution model\n",
    "mass_1_source, mass_2_source = ler.binary_masses_BBH_popI_II_powerlaw_gaussian(size=10000)\n",
    "default_model_dict = dict(mass_1_source=mass_1_source)\n",
    "\n",
    "# calling the custom mass distribution model\n",
    "mass_1_source, mass_2_source = powerlaw_peak(size=10000)\n",
    "custom_model_dict = dict(mass_1_source=mass_1_source)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from ler.utils import plots as lerplt\n",
    "\n",
    "# let's do a comparision plot between you custom model and the default model\n",
    "plt.figure(figsize=(6, 4))\n",
    "lerplt.param_plot(\n",
    "    param_name=\"mass_1_source\", \n",
    "    param_dict=custom_model_dict, # or the json file name\n",
    "    plot_label='custom model',\n",
    ");\n",
    "lerplt.param_plot(\n",
    "    param_name=\"mass_1_source\", \n",
    "    param_dict=default_model_dict,\n",
    "    plot_label='default model',\n",
    ");\n",
    "plt.xlabel(r'source $m_1$ ($M_{\\odot}$)')\n",
    "plt.ylabel(r'$p(source mass_1)$')\n",
    "plt.xlim(0,60)\n",
    "plt.grid(alpha=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Axis-ratio of the lensing \n",
    "\n",
    "* compare the default axis-ratio distribution (gengamma, from SDSS galaxy catalogue, Haris et al. 2018) with axis-ratio distribution from Padilla and Strauss 2008 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "axis_ratio_spline_coeff interpolator will be generated at ./interpolator_pickle/axis_ratio/axis_ratio_spline_coeff_0.pickle\n",
      "axis_ratio interpolator will be loaded from ./interpolator_pickle/axis_ratio/axis_ratio_1.pickle\n"
     ]
    }
   ],
   "source": [
    "size = 10000\n",
    "padilla_strauss = ler.axis_ratio_padilla_strauss(size=size)\n",
    "\n",
    "# axis_ratio_rayleigh depends on the velocity dispersion\n",
    "sigma = ler.velocity_dispersion_gengamma(size=size)\n",
    "rayleigh = ler.axis_ratio_rayleigh(sigma=sigma)\n",
    "\n",
    "# make a dict\n",
    "axis_ratio_dict = dict(\n",
    "    padilla_strauss=padilla_strauss,\n",
    "    rayleigh=rayleigh,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the distribution of axis-ratio\n",
    "plt.figure(figsize=(6, 4))\n",
    "lerplt.param_plot(\n",
    "    param_name=\"padilla_strauss\",\n",
    "    param_dict=axis_ratio_dict,\n",
    "    plot_label='padilla_strauss',\n",
    ")\n",
    "lerplt.param_plot(\n",
    "    param_name=\"rayleigh\",\n",
    "    param_dict=axis_ratio_dict,\n",
    "    plot_label='rayleigh',\n",
    ")\n",
    "plt.xlabel(r'axis ratio')\n",
    "plt.ylabel(r'$p(axis ratio)$')\n",
    "plt.grid(alpha=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting particular number of detectable events\n",
    "\n",
    "* this is particularly useful when you want only the detectable events to be saved in the json file\n",
    "\n",
    "* detectable event rates will be calculated at each batches. Subsequent batch will consider the previous batch's detectable events. So, the rates will become more accurate as the batch number increases and will converge to a stable value at higher samples. \n",
    "\n",
    "* you can resume the rate calculation from the last saved batch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "\n",
    "# class initialization\n",
    "ler = LeR(verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### unlensed case \n",
    "\n",
    "* SNR>8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of detectable events =  0\n",
      "collected number of detectable events =  198\n",
      "total number of events =  50000\n",
      "total unlensed rate (yr^-1): 409.9506704252058\n",
      "collected number of detectable events =  431\n",
      "total number of events =  100000\n",
      "total unlensed rate (yr^-1): 446.18368422541334\n",
      "collected number of detectable events =  621\n",
      "total number of events =  150000\n",
      "total unlensed rate (yr^-1): 428.58479180816965\n",
      "collected number of detectable events =  837\n",
      "total number of events =  200000\n",
      "total unlensed rate (yr^-1): 433.24332215391064\n",
      "collected number of detectable events =  1067\n",
      "total number of events =  250000\n",
      "total unlensed rate (yr^-1): 441.8357225693884\n",
      "collected number of detectable events =  1305\n",
      "total number of events =  300000\n",
      "total unlensed rate (yr^-1): 450.3246000882942\n",
      "collected number of detectable events =  1516\n",
      "total number of events =  350000\n",
      "total unlensed rate (yr^-1): 448.40203200909946\n",
      "collected number of detectable events =  1721\n",
      "total number of events =  400000\n",
      "total unlensed rate (yr^-1): 445.40726250112317\n",
      "collected number of detectable events =  1929\n",
      "total number of events =  450000\n",
      "total unlensed rate (yr^-1): 443.76814997206617\n",
      "collected number of detectable events =  2139\n",
      "total number of events =  500000\n",
      "total unlensed rate (yr^-1): 442.87095153510865\n",
      "collected number of detectable events =  2348\n",
      "total number of events =  550000\n",
      "total unlensed rate (yr^-1): 441.94865663837606\n",
      "collected number of detectable events =  2572\n",
      "total number of events =  600000\n",
      "total unlensed rate (yr^-1): 443.7681499720661\n",
      "collected number of detectable events =  2785\n",
      "total number of events =  650000\n",
      "total unlensed rate (yr^-1): 443.5557953124312\n",
      "collected number of detectable events =  2982\n",
      "total number of events =  700000\n",
      "total unlensed rate (yr^-1): 441.00753939681226\n",
      "collected number of detectable events =  3207\n",
      "total number of events =  750000\n",
      "total unlensed rate (yr^-1): 442.6639057419646\n",
      "collected number of detectable events =  3408\n",
      "total number of events =  800000\n",
      "total unlensed rate (yr^-1): 441.00753939681226\n",
      "collected number of detectable events =  3609\n",
      "total number of events =  850000\n",
      "total unlensed rate (yr^-1): 439.54603968050134\n",
      "collected number of detectable events =  3818\n",
      "total number of events =  900000\n",
      "total unlensed rate (yr^-1): 439.167132346643\n",
      "collected number of detectable events =  4029\n",
      "total number of events =  950000\n",
      "total unlensed rate (yr^-1): 439.0460529354476\n",
      "collected number of detectable events =  4239\n",
      "total number of events =  1000000\n",
      "total unlensed rate (yr^-1): 438.8335585687998\n",
      "collected number of detectable events =  4467\n",
      "total number of events =  1050000\n",
      "total unlensed rate (yr^-1): 440.41597998782925\n",
      "collected number of detectable events =  4649\n",
      "total number of events =  1100000\n",
      "total unlensed rate (yr^-1): 437.52540560302606\n",
      "collected number of detectable events =  4856\n",
      "total number of events =  1150000\n",
      "total unlensed rate (yr^-1): 437.13668326411926\n",
      "collected number of detectable events =  5074\n",
      "total number of events =  1200000\n",
      "total unlensed rate (yr^-1): 437.72931433869826\n",
      "storing detectable unlensed params in ./ler_data/unlensed_params_n_detectable.json\n",
      "\n",
      " trmming final result to size=5000\n"
     ]
    }
   ],
   "source": [
    "n_size_unlensed_param = ler.selecting_n_unlensed_detectable_events(\n",
    "    size=5000, \n",
    "    snr_threshold=8.0,\n",
    "    batch_size=50000,\n",
    "    resume=False,\n",
    "    output_jsonfile='unlensed_params_n_detectable.json',\n",
    "    meta_data_file=\"meta_unlensed.json\",\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Important Note**: At each iteration, rate is calculated using the cummulatively increasing number of events. It become stable at around 2 million events. This is the number of events that is required to get a stable rate.\n",
    "\n",
    "* Now get the sampled (detectable) events."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For lensed case\n",
    "\n",
    "* 2 images, snr>8 (super-threshold)\n",
    "* 1 image, snr>6 (sub+super-threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of detectable events =  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3423.20it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 4/4 [00:02<00:00,  1.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of events =  94\n",
      "total number of events =  50000\n",
      "total lensed rate (yr^-1): 0.46686279136256165\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:13<00:00, 3604.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of events =  199\n",
      "total number of events =  100000\n",
      "total lensed rate (yr^-1): 0.49417923128271146\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3550.29it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.56s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of events =  290\n",
      "total number of events =  150000\n",
      "total lensed rate (yr^-1): 0.4801071258693009\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3527.78it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.63s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of events =  393\n",
      "total number of events =  200000\n",
      "total lensed rate (yr^-1): 0.4879709494826774\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:13<00:00, 3596.58it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 2/2 [00:02<00:00,  1.43s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of events =  484\n",
      "total number of events =  250000\n",
      "total lensed rate (yr^-1): 0.4807693425946379\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:13<00:00, 3631.84it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████| 3/3 [00:02<00:00,  1.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "collected number of events =  578\n",
      "total number of events =  300000\n",
      "total lensed rate (yr^-1): 0.47845158405595845\n",
      "storing detectable lensed params in ./ler_data/unlensed_params_n_detectable.json\n",
      "\n",
      " trmming final result to size=500\n"
     ]
    }
   ],
   "source": [
    "n_size_lensed_param = ler.selecting_n_lensed_detectable_events(\n",
    "    size=500,\n",
    "    snr_threshold=[8.0,6.0],\n",
    "    num_img=[2,1],\n",
    "    batch_size=50000,\n",
    "    resume=False,\n",
    "    output_jsonfile='unlensed_params_n_detectable.json',\n",
    "    meta_data_file=\"meta_lensed.json\",\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'optimal_snr_net', 'L1', 'H1', 'V1'])\n",
      "size of each parameters=500\n"
     ]
    }
   ],
   "source": [
    "print(n_size_lensed_param.keys())\n",
    "print(f\"size of each parameters={len(n_size_lensed_param['zl'])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* let's see the meta file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'events_total': [50000, 100000, 150000, 200000, 250000, 300000, 350000, 400000, 450000, 500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000, 1200000], 'detectable_events': [198.0, 431.0, 621.0, 837.0, 1067.0, 1305.0, 1516.0, 1721.0, 1929.0, 2139.0, 2348.0, 2572.0, 2785.0, 2982.0, 3207.0, 3408.0, 3609.0, 3818.0, 4029.0, 4239.0, 4467.0, 4649.0, 4856.0, 5074.0], 'total_rate': [409.9506704252058, 446.18368422541334, 428.58479180816965, 433.24332215391064, 441.8357225693884, 450.3246000882942, 448.40203200909946, 445.40726250112317, 443.76814997206617, 442.87095153510865, 441.94865663837606, 443.7681499720661, 443.5557953124312, 441.00753939681226, 442.6639057419646, 441.00753939681226, 439.54603968050134, 439.167132346643, 439.0460529354476, 438.8335585687998, 440.41597998782925, 437.52540560302606, 437.13668326411926, 437.72931433869826]}\n"
     ]
    }
   ],
   "source": [
    "from ler.utils import load_json\n",
    "\n",
    "# unlensed\n",
    "meta = load_json('ler_data/meta_unlensed.json')\n",
    "print(meta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using custom detection criteria\n",
    "\n",
    "* let's replace the default calculator in `LeR` with a 'pdet' calculator.\n",
    "\n",
    "* I choose a 'pdet' calculator from gwsnr that's checks whether the event has snr>8 or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ler.rates import LeR\n",
    "from gwsnr import GWSNR\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* let's look at the input and output of 'pdet' calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "psds not given. Choosing bilby's default psds\n",
      "Interpolator will be loaded for L1 detector from ./interpolator_pickle/L1/partialSNR_dict_0.pickle\n",
      "Interpolator will be loaded for H1 detector from ./interpolator_pickle/H1/partialSNR_dict_0.pickle\n",
      "Interpolator will be loaded for V1 detector from ./interpolator_pickle/V1/partialSNR_dict_0.pickle\n"
     ]
    }
   ],
   "source": [
    "snr_ = GWSNR(gwsnr_verbose=False, pdet=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'L1': array([1]), 'H1': array([1]), 'V1': array([1]), 'pdet_net': array([1])}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# initialization pdet calculator\n",
    "pdet_calculator = snr_.snr\n",
    "\n",
    "# test\n",
    "pdet_calculator(\n",
    "    gw_param_dict=dict(\n",
    "        mass_1=np.array([10.0]),\n",
    "        mass_2=np.array([10.0]),\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** pdet function has input==>'gw_param_dict' and output==>'pdet_net'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "ler = LeR(verbose=False, pdet_finder=pdet_calculator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unlensed params will be store in ./ler_data/unlensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling gw source params...\n",
      "calculating pdet...\n",
      "Batch no. 2\n",
      "sampling gw source params...\n",
      "calculating pdet...\n",
      "saving all unlensed_params in ./ler_data/unlensed_param.json...\n"
     ]
    }
   ],
   "source": [
    "unlensed_param = ler.unlensed_cbc_statistics();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['zs', 'geocent_time', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'luminosity_distance', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'L1', 'H1', 'V1', 'pdet_net'])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unlensed_param.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* now calculate rate using the custom 'pdet' calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting unlensed_params from json file ./ler_data/unlensed_param.json...\n",
      "given detectability_condition == 'pdet'\n",
      "total unlensed rate (yr^-1) (with step function): 432.7257076710505\n",
      "number of simulated unlensed detectable events: 418\n",
      "number of all simulated unlensed events: 100000\n",
      "storing detectable unlensed params in ./ler_data/unlensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "_, unlensed_param_detectable = ler.unlensed_rate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lensed params will be store in ./ler_data/lensed_param.json\n",
      "chosen batch size = 50000 with total size = 100000\n",
      "There will be 2 batche(s)\n",
      "Batch no. 1\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:14<00:00, 3480.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 1 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 1/1 [00:02<00:00,  2.75s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating pdet...\n",
      "Batch no. 2\n",
      "sampling lensed params...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████| 50000/50000 [00:13<00:00, 3613.18it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid sample found. Resampling 2 lensed events...\n",
      "solving lens equations...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████| 2/2 [00:02<00:00,  1.39s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calculating pdet...\n",
      "saving all lensed_params in ./ler_data/lensed_param.json...\n"
     ]
    }
   ],
   "source": [
    "ler.batch_size = 50000\n",
    "lensed_param = ler.lensed_cbc_statistics(size=100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['zl', 'zs', 'sigma', 'q', 'theta_E', 'phi', 'e1', 'e2', 'gamma1', 'gamma2', 'gamma', 'ra', 'dec', 'phase', 'psi', 'theta_jn', 'mass_1_source', 'mass_2_source', 'mass_1', 'mass_2', 'x0_image_positions', 'x1_image_positions', 'magnifications', 'time_delays', 'image_type', 'n_images', 'effective_luminosity_distance', 'effective_geocent_time', 'pdet_net'])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lensed_param.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "getting lensed_params from json file ./ler_data/lensed_param.json...\n",
      "given detectability_condition == 'pdet'\n",
      "total lensed rate (yr^-1) (with pdet function): 1.147290476646295\n",
      "number of simulated lensed detectable events: 462\n",
      "number of simulated all lensed events: 100000\n",
      "storing detectable lensed params in ./ler_data/lensed_param_detectable.json\n"
     ]
    }
   ],
   "source": [
    "_, lensed_param_detectable = ler.lensed_rate(detectability_condition='pdet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ler",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}